ஜாவாஸ்கிரிப்ட் தர உள்கட்டமைப்பு: ஒரு முழுமையான செயல்படுத்தல் வழிகாட்டி

வலை மேம்பாட்டின் எப்போதும் மாறிவரும் நிலப்பரப்பில், ஜாவாஸ்கிரிப்ட் ஒரு மூலக்கல்லாக உள்ளது. திட்டங்கள் சிக்கலானதாக வளரும்போதும், அணிகள் உலகம் முழுவதும் பரவி இருக்கும்போதும், குறியீட்டின் தரத்தை உறுதி செய்வது மிக முக்கியமானது. நன்கு வரையறுக்கப்பட்ட மற்றும் செயல்படுத்தப்பட்ட ஜாவாஸ்கிரிப்ட் தர உள்கட்டமைப்பு என்பது இனி ஒரு ஆடம்பரம் அல்ல, மாறாக நம்பகமான, பராமரிக்கக்கூடிய மற்றும் அளவிடக்கூடிய பயன்பாடுகளை உருவாக்குவதற்கான ஒரு தேவையாகும். இந்த விரிவான வழிகாட்டி, உங்கள் ஜாவாஸ்கிரிப்ட் திட்டங்களுக்கு ஒரு வலுவான தர உள்கட்டமைப்பை நிறுவுவதற்கான படிப்படியான அணுகுமுறையை வழங்குகிறது, இது சர்வதேச அணிகள் மற்றும் மாறுபட்ட மேம்பாட்டு சூழல்களுக்கு ஏற்றது.

ஜாவாஸ்கிரிப்ட் தர உள்கட்டமைப்பில் ஏன் முதலீடு செய்ய வேண்டும்?

ஒரு வலுவான தர உள்கட்டமைப்பில் முதலீடு செய்வது பல நன்மைகளைத் தருகிறது:

• மேம்படுத்தப்பட்ட குறியீட்டு நிலைத்தன்மை: முழு குறியீட்டுத் தளத்திலும் ஒரு நிலையான குறியீட்டு பாணியை அமல்படுத்துகிறது, இது டெவலப்பர்களுக்கு புரிந்துகொள்வதையும் பராமரிப்பதையும் எளிதாக்குகிறது. இதை அணியில் உள்ள அனைவரும் சரளமாகப் பேசும் ஒரு பொதுவான மொழியை நிறுவுவது போல எண்ணுங்கள்.
• குறைக்கப்பட்ட பிழைகள் மற்றும் தவறுகள்: மேம்பாட்டு சுழற்சியின் ஆரம்பத்திலேயே சாத்தியமான பிழைகளைக் கண்டறிந்து, அவை உற்பத்திக்குச் செல்வதைத் தடுக்கிறது. இது ஒரு ஆவணம் வெளியிடப்படுவதற்கு முன்பு ஒரு பிழைதிருத்துநர் தவறுகளைக் கண்டுபிடிப்பது போன்றது.
• அதிகரித்த உற்பத்தித்திறன்: ஃபார்மேட்டிங் மற்றும் லிண்டிங் போன்ற மீண்டும் மீண்டும் வரும் பணிகளை தானியங்குபடுத்துகிறது, இது டெவலப்பர்களை மிகவும் சிக்கலான சிக்கல்களைத் தீர்ப்பதில் கவனம் செலுத்த அனுமதிக்கிறது. ஒரு தானியங்கி அசெம்பிளி லைன் உற்பத்தியை நெறிப்படுத்துவதை கற்பனை செய்து பாருங்கள்.
• மேம்படுத்தப்பட்ட ஒத்துழைப்பு: குறியீடு மதிப்பாய்வுகள் மற்றும் விவாதங்களுக்கு ஒரு பொதுவான தளத்தை வழங்குகிறது, இது குறிப்பாக பரவிய அணிகளில் உராய்வைக் குறைத்து குழு ஒத்துழைப்பை மேம்படுத்துகிறது.
• எளிமைப்படுத்தப்பட்ட பராமரிப்பு: குறியீட்டை மறுசீரமைக்கவும் புதுப்பிக்கவும் எளிதாக்குகிறது, புதிய தவறுகளை அறிமுகப்படுத்தும் அபாயத்தைக் குறைக்கிறது. நன்கு ஒழுங்கமைக்கப்பட்ட நூலகத்தை வழிநடத்துவதும் பராமரிப்பதும் எளிது.
• குறைக்கப்பட்ட தொழில்நுட்பக் கடன்: சாத்தியமான சிக்கல்களை முன்கூட்டியே நிவர்த்தி செய்கிறது, காலப்போக்கில் தொழில்நுட்பக் கடன் குவிவதைத் தடுக்கிறது. ஆரம்பகால பராமரிப்பு பின்னர் அதிக செலவாகும் பழுதுபார்ப்புகளைத் தடுக்கிறது.

உலகளாவிய அணிகளுக்கு, நன்மைகள் இன்னும் அதிகமாகின்றன. தரப்படுத்தப்பட்ட குறியீட்டு நடைமுறைகள் கலாச்சார மற்றும் மொழி வேறுபாடுகளைக் குறைத்து, சுமூகமான ஒத்துழைப்பையும் அறிவுப் பகிர்வையும் வளர்க்கின்றன. வட அமெரிக்கா, ஐரோப்பா மற்றும் ஆசியாவில் பரவியிருக்கும் ஒரு அணியைக் கவனியுங்கள்; ஒரு பகிரப்பட்ட தர உள்கட்டமைப்பு, அவர்களின் இருப்பிடம் அல்லது பின்னணியைப் பொருட்படுத்தாமல் அனைவரும் ஒரே பக்கத்தில் இருப்பதை உறுதி செய்கிறது.

ஒரு ஜாவாஸ்கிரிப்ட் தர உள்கட்டமைப்பின் முக்கிய கூறுகள்

1. லிண்டிங்: ஸ்டைல் பிழைகள், சாத்தியமான தவறுகள் மற்றும் குறியீட்டுத் தரங்களுக்கு இணங்குவதை பகுப்பாய்வு செய்தல்.
2. ஃபார்மேட்டிங்: நிலைத்தன்மை மற்றும் வாசிப்புத்தன்மையை உறுதி செய்ய குறியீட்டை தானாகவே வடிவமைத்தல்.
3. டெஸ்டிங்: குறியீட்டின் செயல்பாட்டை சரிபார்க்க சோதனைகளை எழுதுதல் மற்றும் இயக்குதல்.
4. நிலையான பகுப்பாய்வு (Static Analysis): குறியீட்டை இயக்காமல் சாத்தியமான பாதுகாப்பு பாதிப்புகள் மற்றும் செயல்திறன் சிக்கல்களுக்கு பகுப்பாய்வு செய்தல்.
5. தொடர் ஒருங்கிணைப்பு (CI): உருவாக்கம், சோதனை மற்றும் வரிசைப்படுத்தல் செயல்முறையை தானியங்குபடுத்துதல்.

1. ESLint உடன் லிண்டிங்

ESLint என்பது ஒரு சக்திவாய்ந்த மற்றும் மிகவும் உள்ளமைக்கக்கூடிய ஜாவாஸ்கிரிப்ட் லின்டர் ஆகும். இது ஸ்டைல் பிழைகள், சாத்தியமான தவறுகள் மற்றும் குறியீட்டுத் தரங்களுக்கு இணங்குவதை பகுப்பாய்வு செய்கிறது. ESLint பரந்த அளவிலான விதிகள் மற்றும் செருகுநிரல்களை ஆதரிக்கிறது, இது உங்கள் குறிப்பிட்ட தேவைகளுக்கு ஏற்ப தனிப்பயனாக்க உங்களை அனுமதிக்கிறது.

நிறுவுதல் மற்றும் உள்ளமைவு

ESLint-ஐ நிறுவ, பின்வரும் கட்டளையை இயக்கவும்:

            npm install eslint --save-dev
            

              
                Copy
              
            
          

அடுத்து, உங்கள் திட்டத்தின் மூலத்தில் ஒரு ESLint உள்ளமைவு கோப்பை (.eslintrc.js, .eslintrc.yml, அல்லது .eslintrc.json) உருவாக்கவும். ஒரு அடிப்படை உள்ளமைவு கோப்பை உருவாக்க eslint --init கட்டளையைப் பயன்படுத்தலாம்.

            eslint --init
            

              
                Copy
              
            
          

உள்ளமைவு கோப்பு ESLint செயல்படுத்தும் விதிகளைக் குறிப்பிடுகிறது. நீங்கள் பலவிதமான உள்ளமைக்கப்பட்ட விதிகளிலிருந்து தேர்வு செய்யலாம் அல்லது ESLint-ன் செயல்பாட்டை விரிவாக்க மூன்றாம் தரப்பு செருகுநிரல்களைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக, React-குறிப்பிட்ட குறியீட்டுத் தரங்களைச் செயல்படுத்த eslint-plugin-react செருகுநிரலைப் பயன்படுத்தலாம். பல நிறுவனங்கள் திட்டங்கள் முழுவதும் நிலையான பாணிகளுக்காக பகிரக்கூடிய ESLint உள்ளமைவுகளை உருவாக்குகின்றன. AirBnB, Google, மற்றும் StandardJS ஆகியவை பிரபலமான உள்ளமைவுகளின் எடுத்துக்காட்டுகள். முடிவு செய்யும் போது, உங்கள் அணியின் தற்போதைய பாணி மற்றும் சாத்தியமான சமரசங்களைக் கவனியுங்கள்.

ஒரு எளிய .eslintrc.js உள்ளமைவு கோப்பின் எடுத்துக்காட்டு இங்கே:

            module.exports = {
  env: {
    browser: true,
    es2021: true,
    node: true,
  },
  extends: [
    'eslint:recommended',
    'plugin:react/recommended',
  ],
  parserOptions: {
    ecmaFeatures: {
      jsx: true,
    },
    ecmaVersion: 12,
    sourceType: 'module',
  },
  plugins: [
    'react',
  ],
  rules: {
    'no-unused-vars': 'warn',
    'no-console': 'warn',
    'react/prop-types': 'off',
  },
};

            

              
                Copy
              
            
          

இந்த உள்ளமைவு பரிந்துரைக்கப்பட்ட ESLint விதிகளை விரிவுபடுத்துகிறது, React ஆதரவை செயல்படுத்துகிறது, மற்றும் சில தனிப்பயன் விதிகளை வரையறுக்கிறது. no-unused-vars விதி பயன்படுத்தப்படாத மாறிகள் பற்றி எச்சரிக்கும், மற்றும் no-console விதி console.log அறிக்கைகள் பற்றி எச்சரிக்கும். react/prop-types விதி முடக்கப்பட்டுள்ளது, ஏனெனில் இது பெரும்பாலும் TypeScript உடன் பயன்படுத்தப்படுகிறது, இது வகை சரிபார்ப்பை வித்தியாசமாக கையாளுகிறது.

உங்கள் பணிப்பாய்வுடன் ESLint-ஐ ஒருங்கிணைத்தல்

உங்கள் பணிப்பாய்வுடன் ESLint-ஐ பல வழிகளில் ஒருங்கிணைக்கலாம்:

• கட்டளை வரி (Command Line): eslint கட்டளையைப் பயன்படுத்தி கட்டளை வரியிலிருந்து ESLint-ஐ இயக்கவும்.
• எடிட்டர் ஒருங்கிணைப்பு: உங்கள் குறியீடு எடிட்டருக்கு (எ.கா., VS Code, Sublime Text, Atom) ஒரு ESLint செருகுநிரலை நிறுவவும்.
• தொடர் ஒருங்கிணைப்பு (Continuous Integration): ஒவ்வொரு கமிட்டிலும் குறியீட்டை தானாகவே லிண்ட் செய்ய உங்கள் CI பைப்லைனில் ESLint-ஐ ஒருங்கிணைக்கவும்.

கட்டளை வரியிலிருந்து ESLint-ஐ இயக்க, பின்வரும் கட்டளையைப் பயன்படுத்தவும்:

            eslint .
            

              
                Copy
              
            
          

இந்த கட்டளை தற்போதைய அடைவு மற்றும் அதன் துணை அடைவுகளில் உள்ள அனைத்து ஜாவாஸ்கிரிப்ட் கோப்புகளையும் லிண்ட் செய்யும்.

2. Prettier உடன் ஃபார்மேட்டிங்

Prettier என்பது ஒரு கருத்து சார்ந்த குறியீடு ஃபார்மேட்டர் ஆகும், இது நிலைத்தன்மை மற்றும் வாசிப்புத்தன்மையை உறுதி செய்ய குறியீட்டை தானாகவே வடிவமைக்கிறது. சாத்தியமான பிழைகளைக் கண்டறிவதில் கவனம் செலுத்தும் லின்டர்களைப் போலல்லாமல், Prettier குறியீடு வடிவமைப்பில் மட்டுமே கவனம் செலுத்துகிறது.

நிறுவுதல் மற்றும் உள்ளமைவு

Prettier-ஐ நிறுவ, பின்வரும் கட்டளையை இயக்கவும்:

            npm install prettier --save-dev
            

              
                Copy
              
            
          

அடுத்து, உங்கள் திட்டத்தின் மூலத்தில் ஒரு Prettier உள்ளமைவு கோப்பை (.prettierrc.js, .prettierrc.yml, அல்லது .prettierrc.json) உருவாக்கவும். நீங்கள் இயல்புநிலை உள்ளமைவைப் பயன்படுத்தலாம் அல்லது உங்கள் குறிப்பிட்ட தேவைகளுக்கு ஏற்ப தனிப்பயனாக்கலாம்.

ஒரு எளிய .prettierrc.js உள்ளமைவு கோப்பின் எடுத்துக்காட்டு இங்கே:

            module.exports = {
  semi: false,
  trailingComma: 'all',
  singleQuote: true,
  printWidth: 120,
};

            

              
                Copy
              
            
          

இந்த உள்ளமைவு Prettier ஒற்றை மேற்கோள்களைப் பயன்படுத்த வேண்டும், அனைத்து பல-வரி கட்டமைப்புகளுக்கும் பின்வரும் காற்புள்ளிகளைச் சேர்க்க வேண்டும், அரைப்புள்ளிகளைத் தவிர்க்க வேண்டும், மற்றும் அதிகபட்ச வரி நீளத்தை 120 எழுத்துகளாக அமைக்க வேண்டும் என்று குறிப்பிடுகிறது.

உங்கள் பணிப்பாய்வுடன் Prettier-ஐ ஒருங்கிணைத்தல்

உங்கள் பணிப்பாய்வுடன் Prettier-ஐ பல வழிகளில் ஒருங்கிணைக்கலாம்:

• கட்டளை வரி: prettier கட்டளையைப் பயன்படுத்தி கட்டளை வரியிலிருந்து Prettier-ஐ இயக்கவும்.
• எடிட்டர் ஒருங்கிணைப்பு: உங்கள் குறியீடு எடிட்டருக்கு ஒரு Prettier செருகுநிரலை நிறுவவும்.
• Git ஹூக்குகள்: கமிட் செய்வதற்கு முன்பு குறியீட்டை தானாகவே வடிவமைக்க Git ஹூக்குகளைப் பயன்படுத்தவும்.
• தொடர் ஒருங்கிணைப்பு: ஒவ்வொரு கமிட்டிலும் குறியீட்டை தானாகவே வடிவமைக்க உங்கள் CI பைப்லைனில் Prettier-ஐ ஒருங்கிணைக்கவும்.

கட்டளை வரியிலிருந்து Prettier-ஐ இயக்க, பின்வரும் கட்டளையைப் பயன்படுத்தவும்:

            prettier --write .
            

              
                Copy
              
            
          

இந்த கட்டளை தற்போதைய அடைவு மற்றும் அதன் துணை அடைவுகளில் உள்ள அனைத்து கோப்புகளையும் வடிவமைக்கும்.

ESLint மற்றும் Prettier-ஐ ஒருங்கிணைத்தல்

ESLint மற்றும் Prettier ஆகியவை ஒரு விரிவான குறியீட்டு தர தீர்வை வழங்க ஒன்றாகப் பயன்படுத்தப்படலாம். இருப்பினும், முரண்பாடுகளைத் தவிர்க்க அவற்றை சரியாக உள்ளமைப்பது முக்கியம். ESLint மற்றும் Prettier முரண்படலாம், ஏனெனில் ESLint வடிவமைப்பை சரிபார்க்கவும் உள்ளமைக்கப்படலாம்.

ESLint மற்றும் Prettier-ஐ ஒருங்கிணைக்க, நீங்கள் பின்வரும் தொகுப்புகளை நிறுவ வேண்டும்:

            npm install eslint-config-prettier eslint-plugin-prettier --save-dev
            

              
                Copy
              
            
          

eslint-config-prettier தொகுப்பு Prettier உடன் முரண்படும் அனைத்து ESLint விதிகளையும் முடக்குகிறது. eslint-plugin-prettier தொகுப்பு Prettier-ஐ ஒரு ESLint விதியாக இயக்க உங்களை அனுமதிக்கிறது.

இந்த தொகுப்புகளைச் சேர்க்க உங்கள் .eslintrc.js உள்ளமைவு கோப்பைப் புதுப்பிக்கவும்:

            module.exports = {
  // ...
  extends: [
    // ...
    'prettier',
    'plugin:prettier/recommended',
  ],
  plugins: [
    // ...
    'prettier',
  ],
  rules: {
    // ...
    'prettier/prettier': 'error',
  },
};

            

              
                Copy
              
            
          

இந்த உள்ளமைவு prettier உள்ளமைவை விரிவுபடுத்துகிறது, eslint-plugin-prettier செருகுநிரலை செயல்படுத்துகிறது, மற்றும் எந்தவொரு வடிவமைப்பு சிக்கல்களையும் பிழைகளாக புகாரளிக்க prettier/prettier விதியை உள்ளமைக்கிறது.

3. Jest, Mocha, மற்றும் Chai உடன் டெஸ்டிங்

குறியீட்டின் தரத்தை உறுதி செய்வதில் டெஸ்டிங் ஒரு முக்கியமான அம்சமாகும். ஜாவாஸ்கிரிப்ட் பலவிதமான டெஸ்டிங் கட்டமைப்புகளை வழங்குகிறது, ஒவ்வொன்றும் அதன் சொந்த பலங்களையும் பலவீனங்களையும் கொண்டுள்ளது. மிகவும் பிரபலமான சில டெஸ்டிங் கட்டமைப்புகள் பின்வருமாறு:

• Jest: பேஸ்புக்கால் உருவாக்கப்பட்ட ஒரு பூஜ்ஜிய-உள்ளமைவு டெஸ்டிங் கட்டமைப்பு. Jest அதன் பயன்பாட்டின் எளிமை, உள்ளமைக்கப்பட்ட மாக்கிங் திறன்கள் மற்றும் சிறந்த செயல்திறனுக்காக அறியப்படுகிறது.
• Mocha: பரந்த அளவிலான உறுதிமொழி நூலகங்கள் மற்றும் அறிக்கையாளர்களை ஆதரிக்கும் ஒரு நெகிழ்வான மற்றும் விரிவாக்கக்கூடிய டெஸ்டிங் கட்டமைப்பு.
• Chai: Mocha அல்லது பிற டெஸ்டிங் கட்டமைப்புகளுடன் பயன்படுத்தக்கூடிய ஒரு உறுதிமொழி நூலகம். Chai BDD (நடத்தை-சார்ந்த மேம்பாடு) மற்றும் TDD (சோதனை-சார்ந்த மேம்பாடு) உட்பட பலவிதமான உறுதிமொழி பாணிகளை வழங்குகிறது.

சரியான டெஸ்டிங் கட்டமைப்பைத் தேர்ந்தெடுப்பது உங்கள் குறிப்பிட்ட தேவைகள் மற்றும் விருப்பங்களைப் பொறுத்தது. பூஜ்ஜிய-உள்ளமைவு அமைப்பு மற்றும் உள்ளமைக்கப்பட்ட மாக்கிங் திறன்கள் தேவைப்படும் திட்டங்களுக்கு Jest ஒரு நல்ல தேர்வாகும். அதிக நெகிழ்வுத்தன்மை மற்றும் தனிப்பயனாக்கம் தேவைப்படும் திட்டங்களுக்கு Mocha மற்றும் Chai ஒரு நல்ல தேர்வாகும்.

Jest உடன் எடுத்துக்காட்டு

டெஸ்டிங்கிற்கு Jest-ஐ எவ்வாறு பயன்படுத்துவது என்பதைக் காண்பிப்போம். முதலில், Jest-ஐ நிறுவவும்:

            npm install jest --save-dev
            

              
                Copy
              
            
          

பின்னர், நீங்கள் சோதிக்க விரும்பும் குறியீடு உள்ள அதே அடைவில் ஒரு சோதனை கோப்பை (எ.கா., sum.test.js) உருவாக்கவும் (எ.கா., sum.js).

ஒரு sum.js கோப்பின் எடுத்துக்காட்டு இங்கே:

            function sum(a, b) {
  return a + b;
}

module.exports = sum;

            

              
                Copy
              
            
          

மற்றும் ஒரு sum.test.js கோப்பின் எடுத்துக்காட்டு இங்கே:

            const sum = require('./sum');

describe('sum', () => {
  it('should add two numbers correctly', () => {
    expect(sum(1, 2)).toBe(3);
  });

  it('should handle negative numbers correctly', () => {
    expect(sum(-1, 2)).toBe(1);
  });
});

            

              
                Copy
              
            
          

இந்த சோதனை கோப்பு sum செயல்பாட்டிற்கு இரண்டு சோதனை நிகழ்வுகளை வரையறுக்கிறது. முதல் சோதனை நிகழ்வு செயல்பாடு இரண்டு நேர்மறை எண்களை சரியாக கூட்டுகிறதா என்பதை சரிபார்க்கிறது. இரண்டாவது சோதனை நிகழ்வு செயல்பாடு எதிர்மறை எண்களை சரியாக கையாளுகிறதா என்பதை சரிபார்க்கிறது.

சோதனைகளை இயக்க, உங்கள் package.json கோப்பில் ஒரு test ஸ்கிரிப்டைச் சேர்க்கவும்:

            {
  // ...
  "scripts": {
    "test": "jest"
  }
  // ...
}

            

              
                Copy
              
            
          

பின்னர், பின்வரும் கட்டளையை இயக்கவும்:

            npm test
            

              
                Copy
              
            
          

இந்த கட்டளை உங்கள் திட்டத்தில் உள்ள அனைத்து சோதனை கோப்புகளையும் இயக்கும்.

4. TypeScript மற்றும் Flow உடன் நிலையான பகுப்பாய்வு

நிலையான பகுப்பாய்வு என்பது குறியீட்டை இயக்காமல் சாத்தியமான பிழைகள் மற்றும் பாதிப்புகளுக்கு பகுப்பாய்வு செய்வதை உள்ளடக்கியது. இது பாரம்பரிய சோதனை முறைகள் மூலம் கண்டறிய கடினமாக இருக்கும் சிக்கல்களை அடையாளம் காண உதவும். ஜாவாஸ்கிரிப்டில் நிலையான பகுப்பாய்விற்கான இரண்டு பிரபலமான கருவிகள் TypeScript மற்றும் Flow ஆகும்.

TypeScript

TypeScript என்பது ஜாவாஸ்கிரிப்டின் ஒரு சூப்பர்செட் ஆகும், இது மொழிக்கு நிலையான தட்டச்சு சேர்க்கிறது. TypeScript மாறிகள், செயல்பாடுகள் மற்றும் பொருட்களுக்கான வகைகளை வரையறுக்க உங்களை அனுமதிக்கிறது, இது இயக்க நேரத்தில் வகை தொடர்பான பிழைகளைத் தடுக்க உதவும். TypeScript எளிய ஜாவாஸ்கிரிப்டுக்கு தொகுக்கப்படுகிறது, எனவே இது எந்த ஜாவாஸ்கிரிப்ட் இயக்க சூழலுடனும் பயன்படுத்தப்படலாம்.

Flow

Flow என்பது பேஸ்புக்கால் உருவாக்கப்பட்ட ஜாவாஸ்கிரிப்ட்டிற்கான ஒரு நிலையான வகை சரிபார்ப்பு கருவியாகும். Flow வகை தொடர்பான பிழைகளுக்காக குறியீட்டை பகுப்பாய்வு செய்து, டெவலப்பர்களுக்கு உண்மையான நேரத்தில் கருத்துக்களை வழங்குகிறது. Flow தற்போதுள்ள ஜாவாஸ்கிரிப்ட் குறியீட்டுடன் பயன்படுத்தப்படலாம், எனவே அதைப் பயன்படுத்த உங்கள் முழு குறியீட்டுத் தளத்தையும் மீண்டும் எழுதத் தேவையில்லை.

TypeScript மற்றும் Flow இடையே தேர்ந்தெடுப்பது உங்கள் குறிப்பிட்ட தேவைகள் மற்றும் விருப்பங்களைப் பொறுத்தது. வலுவான நிலையான தட்டச்சு மற்றும் மிகவும் கட்டமைக்கப்பட்ட மேம்பாட்டு செயல்முறை தேவைப்படும் திட்டங்களுக்கு TypeScript ஒரு நல்ல தேர்வாகும். நேரம் மற்றும் முயற்சியில் குறிப்பிடத்தக்க முதலீடு இல்லாமல் தற்போதுள்ள ஜாவாஸ்கிரிப்ட் குறியீட்டிற்கு நிலையான தட்டச்சு சேர்க்க விரும்பும் திட்டங்களுக்கு Flow ஒரு நல்ல தேர்வாகும்.

TypeScript உடன் எடுத்துக்காட்டு

நிலையான பகுப்பாய்விற்காக TypeScript-ஐ எவ்வாறு பயன்படுத்துவது என்பதைக் காண்பிப்போம். முதலில், TypeScript-ஐ நிறுவவும்:

            npm install typescript --save-dev
            

              
                Copy
              
            
          

பின்னர், உங்கள் திட்டத்தின் மூலத்தில் ஒரு TypeScript உள்ளமைவு கோப்பை (tsconfig.json) உருவாக்கவும்.

ஒரு எளிய tsconfig.json உள்ளமைவு கோப்பின் எடுத்துக்காட்டு இங்கே:

            {
  "compilerOptions": {
    "target": "es5",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

            

              
                Copy
              
            
          

இந்த உள்ளமைவு TypeScript ES5-க்கு தொகுக்கப்பட வேண்டும், CommonJS தொகுதி அமைப்பைப் பயன்படுத்த வேண்டும், கடுமையான வகை சரிபார்ப்பை இயக்க வேண்டும், மற்றும் கோப்பு பெயர்களில் நிலையான கேசிங்கை அமல்படுத்த வேண்டும் என்று குறிப்பிடுகிறது.

இப்போது, நீங்கள் TypeScript குறியீட்டை எழுத ஆரம்பிக்கலாம். எடுத்துக்காட்டாக, இங்கே ஒரு எளிய TypeScript கோப்பு (greeting.ts):

            function greeting(name: string): string {
  return `Hello, ${name}!`;
}

console.log(greeting("World"));

            

              
                Copy
              
            
          

இந்த கோப்பு greeting என்ற செயல்பாட்டை வரையறுக்கிறது, இது ஒரு string வாதத்தை (name) எடுத்து ஒரு string-ஐ வழங்குகிறது. : string குறிப்பு செயல்பாடு ஒரு string-ஐ வழங்க வேண்டும் என்று குறிப்பிடுகிறது. நீங்கள் வேறு வகையை வழங்க முயற்சித்தால், TypeScript ஒரு பிழையைப் புகாரளிக்கும்.

TypeScript குறியீட்டைத் தொகுக்க, பின்வரும் கட்டளையை இயக்கவும்:

            npx tsc
            

              
                Copy
              
            
          

இந்த கட்டளை உங்கள் திட்டத்தில் உள்ள அனைத்து TypeScript கோப்புகளையும் தொகுத்து அதனுடன் தொடர்புடைய ஜாவாஸ்கிரிப்ட் கோப்புகளை உருவாக்கும்.

5. GitHub Actions, GitLab CI, மற்றும் Jenkins உடன் தொடர் ஒருங்கிணைப்பு (CI)

தொடர் ஒருங்கிணைப்பு (CI) என்பது உருவாக்கம், சோதனை மற்றும் வரிசைப்படுத்தல் செயல்முறையை தானியங்குபடுத்தும் ஒரு மேம்பாட்டு நடைமுறையாகும். CI மேம்பாட்டு சுழற்சியின் ஆரம்பத்திலேயே சிக்கல்களை அடையாளம் கண்டு தீர்க்க உதவுகிறது, உற்பத்திக்குள் தவறுகளை அறிமுகப்படுத்தும் அபாயத்தைக் குறைக்கிறது. பல CI தளங்கள் கிடைக்கின்றன, அவற்றுள்:

• GitHub Actions: GitHub-இல் நேரடியாக ஒருங்கிணைக்கப்பட்ட ஒரு CI/CD தளம். GitHub Actions உங்கள் GitHub ரெபாசிட்டரியில் நேரடியாக உங்கள் பணிப்பாய்வை தானியங்குபடுத்த உங்களை அனுமதிக்கிறது.
• GitLab CI: GitLab-இல் ஒருங்கிணைக்கப்பட்ட ஒரு CI/CD தளம். GitLab CI உங்கள் GitLab ரெபாசிட்டரியில் நேரடியாக உங்கள் பணிப்பாய்வை தானியங்குபடுத்த உங்களை அனுமதிக்கிறது.
• Jenkins: பலவிதமான பதிப்புக் கட்டுப்பாட்டு அமைப்புகள் மற்றும் வரிசைப்படுத்தல் தளங்களுடன் பயன்படுத்தக்கூடிய ஒரு திறந்த மூல CI/CD சர்வர். Jenkins அதிக அளவு நெகிழ்வுத்தன்மை மற்றும் தனிப்பயனாக்கத்தை வழங்குகிறது.

சரியான CI தளத்தைத் தேர்ந்தெடுப்பது உங்கள் குறிப்பிட்ட தேவைகள் மற்றும் விருப்பங்களைப் பொறுத்தது. GitHub அல்லது GitLab-இல் ஹோஸ்ட் செய்யப்பட்ட திட்டங்களுக்கு GitHub Actions மற்றும் GitLab CI நல்ல தேர்வுகள். அதிக நெகிழ்வுத்தன்மை மற்றும் தனிப்பயனாக்கம் தேவைப்படும் திட்டங்களுக்கு Jenkins ஒரு நல்ல தேர்வாகும்.

GitHub Actions உடன் எடுத்துக்காட்டு

CI-க்காக GitHub Actions-ஐ எவ்வாறு பயன்படுத்துவது என்பதைக் காண்பிப்போம். முதலில், உங்கள் GitHub ரெபாசிட்டரியில் ஒரு பணிப்பாய்வு கோப்பை (எ.கா., .github/workflows/ci.yml) உருவாக்கவும்.

ஒரு எளிய .github/workflows/ci.yml பணிப்பாய்வு கோப்பின் எடுத்துக்காட்டு இங்கே:

            name: CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - name: Use Node.js 16
      uses: actions/setup-node@v2
      with:
        node-version: '16.x'
    - name: Install dependencies
      run: npm install
    - name: Run ESLint
      run: npm run lint
    - name: Run Prettier
      run: npm run format
    - name: Run tests
      run: npm test

            

              
                Copy
              
            
          

இந்த பணிப்பாய்வு கோப்பு main கிளைக்கு ஒவ்வொரு புஷ் மற்றும் main கிளையை இலக்காகக் கொண்ட ஒவ்வொரு புல் கோரிக்கை மீதும் இயங்கும் ஒரு CI பைப்லைனை வரையறுக்கிறது. பைப்லைன் பின்வரும் படிகளைக் கொண்டுள்ளது:

1. குறியீட்டை சரிபார்க்கவும் (Checkout the code).
2. Node.js-ஐ அமைக்கவும்.
3. சார்புகளை நிறுவவும் (Install dependencies).
4. ESLint-ஐ இயக்கவும்.
5. Prettier-ஐ இயக்கவும்.
6. சோதனைகளை இயக்கவும்.

CI பைப்லைனை இயக்க, உங்கள் GitHub ரெபாசிட்டரிக்கு பணிப்பாய்வு கோப்பை கமிட் செய்தால் போதும். GitHub Actions தானாகவே பணிப்பாய்வு கோப்பைக் கண்டறிந்து ஒவ்வொரு புஷ் மற்றும் புல் கோரிக்கையிலும் பைப்லைனை இயக்கும்.

குறியீடு மதிப்பாய்வு மற்றும் ஒத்துழைப்பு

தானியங்குபடுத்தல் ஒரு அடித்தளத்தை வழங்கினாலும், மனித மதிப்பாய்வு மற்றும் ஒத்துழைப்பு ஒரு தர உள்கட்டமைப்பின் முக்கியமான பகுதிகளாகும். குறியீடு மதிப்பாய்வுகள் தர்க்கப் பிழைகள், வடிவமைப்பு குறைபாடுகள் மற்றும் தானியங்கு கருவிகள் தவறவிடக்கூடிய சாத்தியமான பாதுகாப்பு பாதிப்புகளைக் கண்டறியும். குழு உறுப்பினர்களிடையே திறந்த தொடர்பு மற்றும் ஆக்கப்பூர்வமான கருத்துக்களை ஊக்குவிக்கவும். GitHub புல் கோரிக்கைகள் அல்லது GitLab ஒன்றிணைப்பு கோரிக்கைகள் போன்ற கருவிகள் இந்த செயல்முறையை எளிதாக்குகின்றன. மரியாதையான மற்றும் புறநிலை விமர்சனங்களை வலியுறுத்துவதை உறுதிசெய்து, பழியைச் சுமத்துவதை விட குறியீட்டை மேம்படுத்துவதில் கவனம் செலுத்துங்கள்.

உலகளாவிய அணிகளுக்கான கருத்தில் கொள்ள வேண்டியவை

உலகளாவிய அணிகளுக்காக ஒரு ஜாவாஸ்கிரிப்ட் தர உள்கட்டமைப்பைச் செயல்படுத்தும்போது, இந்த காரணிகளைக் கவனியுங்கள்:

• நேர மண்டலங்கள்: செயல்திறன் தடைகளைத் தவிர்க்க, வெவ்வேறு நேர மண்டலங்களில் உச்ச நேரம் இல்லாத நேரத்தில் தானியங்கு பணிகளை (CI பில்டுகள் போன்றவை) இயக்க திட்டமிடவும்.
• தொடர்பு: குறியீட்டின் தரம் குறித்த சிக்கல்கள் மற்றும் சிறந்த நடைமுறைகளைப் பற்றி விவாதிக்க தெளிவான தொடர்பு சேனல்களை நிறுவவும். வீடியோ கான்பரன்சிங் மற்றும் பகிரப்பட்ட ஆவணங்கள் புவியியல் இடைவெளிகளைக் குறைக்கலாம்.
• கலாச்சார வேறுபாடுகள்: தொடர்பு பாணிகள் மற்றும் கருத்து விருப்பங்களில் உள்ள கலாச்சார வேறுபாடுகளை மனதில் கொள்ளுங்கள். அனைத்து தொடர்புகளிலும் உள்ளடக்கம் மற்றும் மரியாதையை ஊக்குவிக்கவும்.
• கருவி அணுகல்: அனைத்து குழு உறுப்பினர்களுக்கும் அவர்களின் இருப்பிடம் அல்லது இணைய இணைப்பு ஆகியவற்றைப் பொருட்படுத்தாமல் தேவையான கருவிகள் மற்றும் வளங்கள் கிடைப்பதை உறுதிசெய்யவும். உள்ளூர் சார்புகளைக் குறைக்க கிளவுட் அடிப்படையிலான தீர்வுகளைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள்.
• ஆவணப்படுத்தல்: குறியீட்டுத் தரங்கள் மற்றும் தர உள்கட்டமைப்பு குறித்த விரிவான ஆவணங்களை எளிதில் மொழிபெயர்க்கக்கூடிய வடிவங்களில் வழங்கவும், இதனால் குழு உறுப்பினர்கள் நிறுவனத்தின் சிறந்த நடைமுறைகளைப் பின்பற்ற முடியும்.

முடிவுரை

ஒரு வலுவான ஜாவாஸ்கிரிப்ட் தர உள்கட்டமைப்பை நிறுவுவது என்பது தொடர்ச்சியான முன்னேற்றம் மற்றும் தழுவல் தேவைப்படும் ஒரு தொடர்ச்சியான செயல்முறையாகும். இந்த வழிகாட்டியில் விவரிக்கப்பட்டுள்ள நுட்பங்கள் மற்றும் கருவிகளைச் செயல்படுத்துவதன் மூலம், உங்கள் ஜாவாஸ்கிரிப்ட் திட்டங்களின் தரம், பராமரிப்புத்திறன் மற்றும் அளவிடக்கூடிய தன்மையை கணிசமாக மேம்படுத்தலாம், உங்கள் உலகளாவிய அணிக்கு மிகவும் உற்பத்தி மற்றும் கூட்டுறவான சூழலை வளர்க்கலாம். குறிப்பிட்ட கருவிகள் மற்றும் உள்ளமைவுகள் உங்கள் திட்டத்தின் தேவைகள் மற்றும் உங்கள் அணியின் விருப்பங்களைப் பொறுத்து மாறுபடும் என்பதை நினைவில் கொள்ளுங்கள். உங்களுக்காக வேலை செய்யும் ஒரு தீர்வைக் கண்டுபிடித்து, காலப்போக்கில் அதைத் தொடர்ந்து செம்மைப்படுத்துவதே முக்கியம்.